const express=require('express');
const mongodb=require('./model/packaging.js');
const cookie=require('cookie-parser');
const session=require('express-session');//引入session
const nedbStore=require('nedb-session-store')(session);//引入session持久化保存
const body=require('body-parser');//读取body请求发送过来的文件
const fileupload=require('express-fileupload');//引入文件阅读器
const ejs=require('ejs');//引入模板引擎
const fs=require('fs');
const path=require('path');
const { SSL_OP_SSLEAY_080_CLIENT_DH_BUG } = require('constants');
//服务器
//会话房间编号;不要手动更改
var arr={
	sessionPrivate:'111',//好友号
    sessionGroup:'111',//群聊编号（待办）
	identity:'123456789',//根据此号码给每个注册的用户生成一个专属的身份号，操作用户直接身份证号（待办）
}
arr=JSON.stringify(arr);
//先找一下有没有这个文件，没有就创建一个;
fs.readFile('./public/session.json',(err,f)=>{
	if(err){
        fs.writeFile('./public/session.json',arr,(err)=>{
			if(err) throw err;
		})
	}
})
const app=express();
app.set('view engine','ejs');
const http=require('http').Server(app);//引入http
const io=require('socket.io')(http);
app.use(cookie());//
app.use(fileupload());//
//传入body中间件，解析post数据
app.use(body.urlencoded({
	extended:true,}));
//登陆页面,进入登陆页面
//呈递静态资源
app.use('/public',express.static('./public/'));
//进入登陆页面
app.use('/index',(req,res)=>{
	res.render('index');
});
//注册页面
app.use('/login',(req,res)=>{
	res.render('login');
});
//主页面
app.use('/homePage',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
        res.render('homePage');
	}
	
});
//多人聊天室
app.use('/GroupChat',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
		res.render('GroupChat');
	}
})
//接收注册信息
app.use('/loginss',(req,res)=>{
	//账号是唯一的。用户名可以重复。
	
	let user={name:req.body.user};
	// 要先对比再查找
	// 拿到的数据插入数据库
	//注册需要包含用户身份证，因为数据id是可不修改字段，
	mongodb.find('user','ID',user,(a)=>{
		// console.log(a);
		if(a.length==0){
			var temp;
            fs.readFile('./public/session.json',(err,data)=>{
				if(err) throw err;
				let file=JSON.parse(data);
				let number=file.identity;
				number=parseInt(number);
				number+=1;
				temp=number;
				//设置回去
				temp=JSON.stringify(temp);
				file.identity=number;
                file=JSON.stringify(file);
				let obj={
					user:req.body.user,//账号
					name:req.body.name,//用户名
					password:req.body.password,//密码
					AddFriend:[],//好友申请列表
					friendList:[],//好友列表
					sessionList:[],//会话列表，用于开启临时会话
					groupChat:[],//群聊
					identity:temp,//身份证号
					headSrc:'',
				}
				mongodb.insert('user','ID',obj,(a)=>{
					res.send('true');
				})	
				fs.writeFile('./public/session.json',file,(err)=>{
					if(err) throw err;
				})
			})          
		}else{
			res.send('false');
		}
	})
})
//登陆
app.use('/go',(req,res)=>{
	let obj={
	    'user':req.body.user,
		'password':req.body.password,
	}
	let user={
		'user':req.body.user,
        }
	mongodb.find('user','ID',user,(a)=>{
		if(a.length==0){
			res.send('账号未注册');
		}else if(obj.user==a[0].user&&obj.password==a[0].password){
			let name=a[0].name;
			res.cookie('names',name,{maxAge:100000000,httponly:true});
             res.send('true');
		}else{
			res.send('false');
		}
	})
})
//登陆进来之后获取用户信息

app.use('/getuserinfo',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
        //用户的身份证
 		let obj={
			identity:req.body.identity
		}
		mongodb.find('user','ID',obj,(a)=>{
			res.send(a);
		})
	}
	
})

// //获取·cookie
app.use('/getName',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
		//通过cookie获取用户信息
		mongodb.find('user','ID',{name:req.cookies.names},(a)=>{
            res.send(a);
		})
	}
})
//修改名称(更新数据)
//修改名称需要更新整个数据库里的同一名字
app.use('/changename',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
		//修改的是自己的名字
        let news={name:req.body.news};
	    let odl={name:req.cookies.names};
	    //将新的用户名设置为cookie
	    mongodb.update('user','ID',odl,news,(s)=>{
		//修改成功之后重新拿下数据
	    	mongodb.find('user','ID',news,(a)=>{
				//到了这一步自身的用户名已更新;需要更新其他地方与我有关系的相同名字
		    	var names=a[0].name;
			    res.cookie('names',names,{maxAge:100000000,httponly:true});
			    res.send(a);
		    })
     	})
    }
})
//修改账号(更新数据)
app.use('/changeuser',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
        let news={user:req.body.news};
	    let odl={name:req.cookies.names};
	    mongodb.update('user','ID',odl,news,(s)=>{
		//修改成功之后重新拿下数据
		    mongodb.find('user','ID',news,(a)=>{
			    res.send(a);
		    });
	    });
	}
	
});
//修改头像
app.use('/headSrc',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
		let myurl=req.files;
		const fileName = req.files.myfile.name
		const path = __dirname  +'/public/image/'+ fileName;//保存图片的路径
		myurl.myfile.mv(path);
		let odl={
			name:req.cookies.names,
		}
		let news={
			name:req.cookies.names,
			headSrc:"../public/image/"+fileName,
		}
		mongodb.update('user','ID',odl,news,(s)=>{
			mongodb.find('user','ID',news,(a)=>{
				res.send(a);
			});
		});
	}

});
//发布朋友圈消息 
app.use('/setCompileImg',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
        let myurl=req.files;
		let imgName=myurl.img.name;
		const path = __dirname  +'/public/compileImg/'+ imgName;//保存图片的路径
		myurl.img.mv(path);
        res.send('true');

	}
})
//只有分两次了
app.use('/setCompileNews',(req,res)=>{
    if(!(req.cookies.names)){
		res.render('index');
	}else{
        //判断用户名cookie是否存在
		let obj={
			name:req.cookies.names,
		}
		mongodb.find('user','ID',obj,(a)=>{
			let ovl={
				pinglun:req.body.val,//朋友圈文字内容
				time:req.body.time,//发表的时间
				name:req.cookies.names,//用户名
				headsrc:a[0].headSrc,//头像地址
				img:req.body.img,//发表的图片
				likelist:[],//点赞列表 爱心和用户名
				commentlist:[],//评论列表，评论时间，用户名头像，内容
				identity:a[0].identity,//身份证号用于验证信息
			}
			mongodb.insert('user','word',ovl,(s)=>{
				res.send('ture');
			})
		})
	}
})
//获取朋友圈信息
app.use('/getCompileNews',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
        let obj={
			name:req.cookies.names,
		};

		mongodb.findAll('user','word',(s)=>{
			res.send(s);
		})
	}
})
// //点赞朋友圈//为了让它成为一个公共的方法。需要让好友都可以点赞；
// //和模板不同别人的数据是固定的
app.use('/likeFriend',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
        	//1,根据发送过来的时间确定是哪一条数据
	    let time={
		    time:req.body.time,
	    }
	    let identity={identity:req.body.identity};//朋友圈消息里存的身份证号
        mongodb.find('user','ID',{name:req.cookies.names},(a)=>{//找到我的身份证
		    mongodb.find('user','word',time,(s)=>{//根据谁发的消息找到对应集合的数据
		        let newLikeList=JSON.stringify(s[0].likelist);//消息列表
			    newLikeList=JSON.parse(newLikeList);//转化成字符串深拷贝
			    let username={
					name:req.cookies.names,
				    identity:a[0].identity,//我的身份证号
				}//我的用户名
			    let temp=false;//判断该条消息点赞列表，是否有我自己
			    for(let i=0;i<newLikeList.length;i++){
					//如果有temp为true
					console.log(newLikeList);
				    if(newLikeList[i].identity==username.identity){
					    temp=true;
					    break;
				    }
			    }
			    //如果temp为true了表示有了
			    if(temp==true){
				    //先用简单暴力的方法
                    // 如果有就删除,将更新后的数据返回到前端
				    //不用删除的方法用更新的方法
				    for(let i=0;i<newLikeList.length;i++){
					    //如果有temp为true
					    if(newLikeList[i].identity==username.identity){
						    newLikeList.splice(i,1);
					    };
				    };
				    let news={
					    likelist:newLikeList,
					    time:req.body.time,
						identity:s[0].identity,//增加身份证
				    };
				    let odl={
					    likelist:s[0].likelist,
					    time:req.body.time,
				    }
				    mongodb.update('user',`word`,odl,news,(q)=>{
					    mongodb.findAll('user','word',(s)=>{
							res.send(s);
						})
				    })
			    }else{
				    // 没有的话就需要,把点赞加上,将用户名追加到该条数据里，在返回给前端
				    //方法，将拿出来的数据，修改再更新;
				    //并没有保存进去，转成字符串，在转回来可以实现深拷贝
				    //更新数据
				    //插入之前要先找一下，这样增加了复杂度
					// 确定找到再更新,还要通过时间确定是那条数据
					// 将整条数据拿出来，更新
					//s是未更新的原始数据
					let like=JSON.stringify(s[0]);
					like=JSON.parse(like);
					like.likelist.push(username);
					//更新数据
					// s是拿到的数据
					let news={
						likelist:like.likelist,
						time:req.body.time,
						identity:s[0].identity,//增加身份证

					}
					let odl={
						likelist:s[0].likelist,
						time:req.body.time,
					}
			        mongodb.update('user','word',odl,news,(q)=>{
						//这里应该返回我自己的数据
						mongodb.find('user','ID',{name:req.cookies.names},(b)=>{
							mongodb.find('user','word',{},(data)=>{
								res.send(data);
							})
						})
                       
					})
		        }
		   })
	    })
	}
})
//删除朋友圈消息
app.use('/delmoments',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
		//这里是我自己的用户名
        let name={name:req.cookies.names};//获取cookie保存的用户名
	    let time={time:req.body.time};//时间线
	    //通过name找到所在集合
	    mongodb.find('user','ID',name,(a)=>{
		//找到之后，
		mongodb.del('user','word',(s)=>{
			mongodb.findAll('user','word',(e)=>{
				    res.send(e);
			    })
		    },time)
    	})
	}
});
//朋友圈评论消息
app.use('/commentNews',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
        let name={
			name:req.cookies.names,
		}
		//需要找到自己的头像路径，将其保存到评论的消息中
		mongodb.find('user','ID',name,(a)=>{
			let headSrc=a[0].headSrc;
			let time1=req.body.time1;//该条朋友圈发布的时间
			let time=req.body.time;//现在的时间
			//找到评论消息的专属集合
			mongodb.find('user',`word`,{time:time1},(s)=>{
				let commentlist=s[0].commentlist;//原有的数据
				//转成字符串复制
				let newcommentlist=JSON.stringify(commentlist);
				newcommentlist=JSON.parse(newcommentlist);//
				let arr={
						name:req.cookies.names,
						headSrc:headSrc,
						time:time,
						val:req.body.val,
						identity:s[0].identity,//增加身份证
					};
				newcommentlist.push(arr);
				// 旧的
				let odl={
					time:time1,
					commentlist:commentlist,
				}
				//新的
				let news={
					time:time1,
					commentlist:newcommentlist,
				}
				mongodb.update('user',`word`,odl,news,(e)=>{
					mongodb.findAll('user',`word`,(k)=>{
						res.send(k);
					})
				})
			})
		})
	}
})
//删除朋友圈评论
app.use('/delComment',(req,res)=>{
    if(!(req.cookies.names)){
		res.render('index');
	}else{
        //一，根据发布人名字找到数据所在集合的名字
	    //二，根据集合名字找到所在集合
	    //三，根据发布时间找到对应的数据/加工成数组
	    //四，根据评论时间找到评论的数据删除
	    //五，更新数据，返回到前台。
	    //朋友圈发布人身份证号
	    let identity={
		    identity:req.body.identity,
	    }
	    ////朋友圈发布时间
	    let issueTime={
		    time:req.body.issueTime,
	    }
	    //评论时间
	    let commentTime={
		    time:req.body.commentTime,
	    }
	    mongodb.find('user','ID',identity,(a)=>{
		    mongodb.find('user',`word`,issueTime,(r)=>{
			    let data=JSON.stringify(r[0]);
			    data=JSON.parse(data);
			    //复制
			    let commentlist=JSON.stringify(data.commentlist);
			    commentlist=JSON.parse(commentlist);
			    //循环遍历
			    for(var i=0;i<commentlist.length;i++){
				    if(commentTime.time==commentlist[i].time){
					    commentlist.splice(i,1);
					    break;
				    }
			    }
			    let odl={
				    commentlist:data.commentlist,
				    time:req.body.issueTime,
			    };
			    let news={
				    commentlist:commentlist,
				    time:req.body.issueTime,
			    };
			    //应该是该条数据的发布时间
			    //id是不可改变的
			    mongodb.update('user',`word`,odl,news,(s)=>{
				    mongodb.findAll('user',`word`,(e)=>{
					    res.send(e);
				    })
     			})
	    	})
	   })
	}
})
// 搜索用户
app.use('/friendly',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
		let obj=req.query.name;
		mongodb.inquire('user','ID','name',obj,(a)=>{
			res.send(a);
		})	
	}
})
// 加好友
// 1，我需要一个好友申请列表
// 2，被申请人根据好友申请列表，同意是否添加好友
//2，关系为好友的朋友圈关系是可见的
app.use('/AddFriend',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
         //需要添加的好友的身份证号
	    let identity={
		    identity:req.body.identity,
	    }
	    //找到该用户
	    mongodb.find('user','ID',identity,(a)=>{
		    let identity=a[0].identity;//目标用户的账号；
		    if(a[0].AddFriend){
			    var AddFriend=JSON.stringify(a[0].AddFriend);
			    AddFriend=JSON.parse(AddFriend);
		    }else{
			    var AddFriend=[];
	    	}
		    let on=true;
		    //要判断一下这个列表中有没有相同的申请信息，如果有就不添加，
		    for(var i=0;i<AddFriend.length;i++){
			    if(AddFriend[i].name==req.cookies.names){
				    //如果有也将数据拿到前台
				    on=false;
			   };
	    	};
		    //追加进去/这里要追加的应该是添加人的信息
		    if(on){
			    let myName={
				    name:req.cookies.names,
			    }
			    //找到我自己的信息
			    mongodb.find('user','ID',myName,(s)=>{
				//要保存自己的用户名，头像
				let nameAndSrc={
					name:s[0].name,
					headSrc:s[0].headSrc,
					val:req.query.val,//验证信息。
					identity:s[0].identity,//身份证信息
				}
				AddFriend.push(nameAndSrc); 
				//将需要添加好友的用户信息更新，需要用到目标用户的账号
				let news={
					identity:identity,
					AddFriend:AddFriend
				}
				let odl={
					identity:identity,
				}
				//更新//我加别人好友是不显示添加信息的，添加信息会在别人那里显示
				//只有自己加自己的时候才显示，其他一律不显示//目标账户的身份证号等同于我的身份证号时表示自己加自己
				mongodb.update('user','ID',odl,news,(k)=>{
					    mongodb.find('user','ID',news,(e)=>{
						    if(nameAndSrc.identity==identity.identity){
								
							    res.send(e);
						    }else{
							    res.send('false');
						    }
     					})	
	     			})		 
		    	})	
		    }else{
			     res.send('false');
	     	}
	    })
	}
});
// 不同意加好友 //见鬼了
app.use('/vuto',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
		let myName={
			name:req.cookies.names,
		}
		//先找到自己的信息
		mongodb.find('user','ID',myName,(a)=>{
			 //拿到 好友申请列表
			let AddFriend=a[0].AddFriend;
			//申请人的身份证号
			let identity=req.query.identity;
			//对比 ,如果有删除该条数据
			for(var i=0;i<AddFriend.length;i++){
				if(AddFriend[i].identity==identity){
					AddFriend.splice(i,1);
				}
			}
			//在更新一下数据，需要和账号一起更新
			let odl={
				user:a[0].user,
			}
			let news={
				user:a[0].user,
				AddFriend:AddFriend
			};
			mongodb.update('user','ID',odl,news,(s)=>{
			   //重新获取数据
			})
			mongodb.find('user','ID',odl,(data)=>{
				res.send(data);
			})
	
		})
	}
   
})
//同意加好友
//除了删除好友申请列表外，还需要获取好友信息添加到好友列表
//思路
//1.先找到我的好友申请列表信息，
//2.与当前申请人名字对比
//3.将对比成功的信息从好友申请列表，移动到好友信息列表
//4.好友添加是双向的，将我的信息添加到好友的好友信息列表中
app.use('/consent',(req,res)=>{
    if(!(req.cookies.names)){
		res.render('index');
	}else{
        //根据cookie找到我的信息
	    let myName={
		    name:req.cookies.names,
	    }
		// 在加好友的时候就生成好友号
		var number;
		fs.readFile('./public/session.json',(err,da)=>{
			if(err) throw err;
		    let room=JSON.parse(da);
			let n=room.sessionPrivate
			n=parseInt(n);//生成房间
			n+=1;		
			n=JSON.stringify(n);
			number=n;//拿到房间号
			room.sessionPrivate=n;
			room=JSON.stringify(room);
			// console.log('。。。。。。。。。。。。')
            // console.log(room);
			// console.log('。。。。。。。。。。。。')

			fs.writeFile('./public/session.json',room,(err)=>{
                if(err) throw err;
			})
			mongodb.find('user','ID',myName,(a)=>{
				//好友申请列表
				let AddFriend=a[0].AddFriend;
				//与当前申请人身份证号字对比,需要确定是谁加我为好友
				let identity=req.query.identity;
				for(var i=0;i<AddFriend.length;i++){
					if(AddFriend[i].identity==identity){
						var temp=AddFriend[i];
						//转为字符串复制
						temp=JSON.stringify(temp);
						temp=JSON.parse(temp);
						AddFriend.splice(i,1);
					}
				}
				//更新我的好友列表，好友申请列表
				let friendList=JSON.stringify(a[0].friendList);
				friendList=JSON.parse(friendList);
				//确定好友列表是否已经有好友
				let len=true;
				//当前身份证是好友的与我对比
				for(var i=0;i<friendList.length;i++){
					if(identity==friendList[i].identity){
						len=false;
					}
				}
				//避免重复加好友
				if(len){
					temp.room=number;
					friendList.push(temp);		 	
				}
				let myOdl={
					identity:a[0].identity,
				}
				let myNews={
					identity:a[0].identity,
					AddFriend:AddFriend,
					friendList:friendList,
				}
				//更新我的好友列表
				mongodb.update('user','ID',myOdl,myNews,(b)=>{
					//将我的数据更新到好友的好友列表
					mongodb.find('user','ID',{identity:identity},(d)=>{
						let herFriend=JSON.stringify(d[0].friendList);
						herFriend=JSON.parse(herFriend);
						let one=true;//去重
						for(var i=0;i<herFriend.length;i++){
							if(a[0].identity=herFriend[i].identity){
								one=false;
							}
						}
						//我的用户名和头像
						let myData={
							name:myName.name,
							headSrc:a[0].headSrc,
							identity:a[0].identity,
							room:number,//我的身份证号;
						}
						if(one){
							herFriend.push(myData);
						}
						let herOdl={
							identity:d[0].identity,
						}
						let herNews={
							identity:d[0].identity,
							friendList:herFriend,
						}
						//更新好友的好友列表1
						mongodb.update('user','ID',herOdl,herNews,(e)=>{
							mongodb.find('user','ID',myNews,(c)=>{
								res.send(c);
							})
						})
					 })		
			        })
			
		})
	    //我的好友列表信息
	   
	   })
	}
})
//删除好友,删除好友其实删除的是好友列表里的数据(用户名/头像)，以及对方好友列表里我的数据
app.use('/delfriend',(req,res)=>{
    if(!(req.cookies.names)){
		res.render('index');
	}else{
		//获取我的数据将其要删除的好友数据更新掉
		let myName=req.cookies.names;
	    mongodb.find('user','ID',{name:myName},(a)=>{
			//拿到我的数据对其更新
			let friendList=JSON.stringify(a[0].friendList);
            friendList=JSON.parse(friendList);
			//好友的身份证
  			let herIdentiyt=req.body.identity;
            //和我的好友列表进行对比
			for(var i=0;i<friendList.length;i++){
				if(friendList[i].identity==herIdentiyt){
					friendList.splice(i,1);
				}
			} 
			let myOdl={
				identity:a[0].identity,
			}
			let myNews={
				identity:a[0].identity,
				friendList:friendList,
			}
			// 更新
			mongodb.update('user','ID',myOdl,myNews,(b)=>{
				mongodb.find('user','ID',{name:req.cookies.names},(c)=>{
					res.send(c);
				})
			})
		})
	}
})
//以上代码，在架构的时候，偏离了方向，功能上做了改动，朋友圈更改为世界频道，数据储存到word集合，以时间线为轴。
//针对修改用户名，会造成找不到用户的问题，决定不在使用用户名查找，而使用该条数据的id查找，就算更改了可变信息也不会造成数据丢失
//开启临时会话
//思路，在会话列表中添加会话的房间号信息.房间号是唯一的，如何生成房间号
//发送消息的前提就是判断有没有专属的房间，如果有，直接进入发送消息页面，并将房间（集合的数据）展示出来
app.use('/sendSession',(req,res)=>{
	if(!(req.cookies.names)){
		res.render('index');
	}else{
        //读取房间编号
		//这里要做的是什么
		//1，获取前台传来该好友的身份证
		//1.根据身份证编号，找到该好友在好友列表中的信息，将其添加到临时会话列表
        //因为是好友所以无需验证
		let herIdentiyt=req.body.identity;
		let myName=req.cookies.names;
		let temp;
		mongodb.find('user','ID',{name:myName},(a)=>{
            let friendList=a[0].friendList;//好友列表
			for(var i=0;i<friendList.length;i++){
				if(friendList[i].identity==herIdentiyt){
				    
				    temp=friendList[i];	
				}
			}
			
            //将该数据追加到我的临时会话列表,需要判断我的会话列表中是否有自己，如果有就不添加
			//追加
			let sessionList=a[0].sessionList;
			//判断/这个列表是我·的
			var on=true;
			for(var i=0;i<sessionList.length;i++){
                if(sessionList[i].identity==herIdentiyt){
                    on=false;
				}
			}
			if(temp){
				if(on){
				    sessionList.push(temp); 
				}
			}
            //更新数据
			var odl={
				identity:a[0].identity,
			}
			var news={
				identity:a[0].identity,
				sessionList:sessionList,
			}
			mongodb.update('user','ID',odl,news,(b)=>{
               //更新完毕之后，还需要将该好友的临时会话列表页更新
			    //通过好友身份证，找到该好友数据
				//还要判断一下是不是自己加自己，是自己加自己就结束，避免重复加自己;
				mongodb.find('user','ID',{identity:herIdentiyt},(c)=>{
					if(c[0].identity==a[0].identity){
						mongodb.find('user','ID',{name:myName},(e)=>{
							res.send(e);
						})
					}else{
						let herfriendList=c[0].friendList;
						let temp2;
						for(var i=0;i<herfriendList.length;i++){
							if(a[0].identity==herfriendList[0].identity){
								//这种情况表示，找到好友列表中我的数据
								temp2=herfriendList[i];
							};
						}
						let odls={
							identity:c[0].identity,
						} 
						//上面的好友会话列表是我的·
						//下面应该是好友的
						let sessionList2=c[0].sessionList;
						var on=true;
						//这里是对比好友回话中是否有我的信息
						for(var i=0;i<sessionList2.lenth;i++){
							if(sessionList2[i].identity==a[0].identity){
                                on=false;
							}
						}
						if(temp2){
							if(on){
							    sessionList2.push(temp2) 
							}
						}
						let newss={
							identity:c[0].identity,
							sessionList:sessionList2,
						} 
						mongodb.update('user','ID',odls,newss,(d)=>{
							//更新完毕以后，返回我的数据
							mongodb.find('user','ID',{name:myName},(e)=>{
								res.send(e);
							})
						})
					}
				})
			})
		})
	}
})
app.use('/wordNews',(req,res)=>{
    mongodb.findAll('user','worsNews',(a)=>{
		let len=a.length;
		let skip=len-20;
        if(skip<0){
			skip=0;
		}
		mongodb.findAll('user','wordNews',(b)=>{
		    res.send(b);
             
		},skip,20);
	}) 
})
//获取好友之间的私信;
io.on('connection',(socket)=>{
	//多人聊天室
	socket.on('chat',(a)=>{
		mongodb.insert('user','wordNews',a,(s)=>{
		    io.emit('send',a);
		})
	})
	//在回调中可以处理一些事情
	socket.on('interflow',(a)=>{
        let room=a.room;
		console.log(a);
		//将接收的数据放入私信的集合里
		console.log(room);
		mongodb.insert('user',`${room}`,a,(s)=>{
		})
		io.emit('all',a);
	})
})
//一进入私聊页面初始化
app.use('/words',(req,res)=>{
	let room=req.body.room;
	mongodb.findAll('user',`${room}`,(a)=>{
		//获取最新20条
		let skip=a.length;
		skip=skip-20;
		if(skip<0){
			skip=0;
		}
		console.log(room);
		mongodb.findAll('user',`${room}`,(b)=>{
			res.send(b)
		},skip,20);
	})
})
app.use('/',(req,res)=>{
	res.render('index');
});
http.listen('9999');